<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title></title>

</head>

<script>
    
    // 探究async function执行后的返回值: 返回的是一个Promise
    var return_value = (async function () {})()
    console.log(return_value)

    
    
    
    /* 
        探究async function返回值对其执行后返回的Promise的影响(与原Promise中then()返回值对返回Promise影响相同):
            - 当返回值是一个非Promise值时, 返回的Promise状态为fulfilled, 值为这个非Promise值
            - 当抛出一个对象时, 返回的Promise状态为rejected, 值为这个被抛出的对象
            - 当返回值是一个Promise值时, 返回的Promise状态、值与这个Promise相同
    */
    var return_value2 = (async function () {
        //return 1
        //throw 2
        //return Promise.resolve(3)
        //return Promise.reject(3)
        return new Promise((resolve)=>{
            setTimeout(()=>{
                resolve('异步返回一个fulfilled的Promise')
            }, 1500)
        })
    })()
    console.log(return_value2)
    return_value2.then(
        value => {
            console.log('成功', value)
        },
        reason => {
            console.log('失败', reason)
        }
    )




    /*
        探究await关键字
            出现位置:
                await关键字只能出现在async function中, 
                而async function中可以没有await关键字
            
            await expression中的expression取值:
                1. 可以是js普通数据类型/引用数据类型
                2. 更常见的是Promise对象

            expression取值对await的影响:
                - 如果是js普通数据类型/引用数据类型的值, 则await直接返回该值
                - 如果是Promise对象
                    - 当Promise是成功时, await返回成功Promise的值
                    - 当Promise是失败时, await会报错
    */

    function fn1 () {
        return 'fn1()同步返回的是普通值--String'
    }

    function fn2 () {
        throw 'fn2()同步抛出一个异常'
    }

    function fn3 () {
        return Promise.resolve('fn3()同步返回一个fulfilled的Promise')
    }

    function fn4 () {
        return new Promise((resolve)=>{
            setTimeout(()=>{
                resolve('fn4()异步返回一个fulfilled的Promise')
            }, 1500)
        })
    }

    function fn5 () {
        return new Promise((resolve, reject)=>{
            setTimeout(()=>{
                reject('fn5()异步返回一个rejected的Promise')
            }, 1500)
        })
    }


    var asyncFunc = async function () {
        // var return_value = await fn1()
        // var return_value = await fn2()
        // var return_value = await fn3()
        // var return_value = await fn4()
        
        /* try {
            var return_value = await fn5()
            console.log('得到异步的返回值', return_value)
        } catch (error) {
            console.log('得到异步的返回值', error)
        } */

        var return_value = await fn5().catch(error => error)
        console.log('得到异步的返回值', return_value)
        
        
        return 'async function的执行返回的Promise能够读取'
    }

    var p = asyncFunc()
    p.then(
        r => console.log(r)
    )



</script>

<body>
    
</body>

</html>
